package com.company.mtp.device.factory;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.company.mtp.device.api.DeviceManager;

/**
 * 设备管理工厂类
 * 实现设备管理的可插拔设计，支持动态获取不同类型的设备管理器
 * 
 * @author mtp
 */
@Service
public class DeviceManagerFactory {
    
    private static final Logger log = LoggerFactory.getLogger(DeviceManagerFactory.class);
    
    /**
     * 通过Spring自动注入所有实现了DeviceManager接口的Bean
     * 这里利用了Spring的依赖注入特性，实现了组件的自动发现和注册
     */
    @Autowired
    private Map<String, DeviceManager> deviceManagers;
    
    /**
     * 设备管理器实例缓存，用于存储已初始化的管理器实例
     */
    private final Map<String, DeviceManager> managerInstances = new ConcurrentHashMap<>();
    
    /**
     * 获取指定类型的设备管理器
     * 
     * @param managerType 管理器类型
     * @return 设备管理器实例
     * @throws IllegalArgumentException 如果不支持指定的管理器类型
     */
    public DeviceManager getManager(String managerType) {
        // 首先检查缓存中是否已有实例
        DeviceManager cachedManager = managerInstances.get(managerType);
        if (cachedManager != null) {
            return cachedManager;
        }
        
        // 从Spring容器中查找对应的管理器实现
        DeviceManager manager = deviceManagers.get(managerType + "Manager");
        if (manager == null) {
            log.error("不支持的设备管理器类型: {}", managerType);
            throw new IllegalArgumentException("不支持的设备管理器类型: " + managerType);
        }
        
        // 将实例放入缓存
        managerInstances.put(managerType, manager);
        log.info("成功获取设备管理器: {}, 版本: {}", managerType, manager.getVersion());
        
        return manager;
    }
    
    /**
     * 获取指定类型和平台的设备管理器
     * 
     * @param managerType 管理器类型
     * @param platform 平台类型 (Android, iOS, Web)
     * @return 设备管理器实例
     * @throws IllegalArgumentException 如果不支持指定的管理器类型或平台
     */
    public DeviceManager getManager(String managerType, String platform) {
        DeviceManager manager = getManager(managerType);
        
        // 检查管理器是否支持指定平台
        boolean supported = false;
        for (String supportedPlatform : manager.getSupportedDeviceTypes()) {
            if (supportedPlatform.equalsIgnoreCase(platform)) {
                supported = true;
                break;
            }
        }
        
        if (!supported) {
            log.error("设备管理器 {} 不支持平台: {}", managerType, platform);
            throw new IllegalArgumentException("设备管理器 " + managerType + " 不支持平台: " + platform);
        }
        
        return manager;
    }
    
    /**
     * 获取所有可用的设备管理器类型
     * 
     * @return 管理器类型列表
     */
    public String[] getAvailableManagerTypes() {
        return deviceManagers.keySet().stream()
                .map(name -> name.replace("Manager", ""))
                .toArray(String[]::new);
    }
    
    /**
     * 初始化指定类型的设备管理器
     * 
     * @param managerType 管理器类型
     * @param config 管理器配置
     * @return 初始化后的设备管理器实例
     */
    public DeviceManager initializeManager(String managerType, Map<String, Object> config) {
        DeviceManager manager = getManager(managerType);
        manager.initialize(config);
        return manager;
    }
    
    /**
     * 关闭并移除指定类型的设备管理器实例
     * 
     * @param managerType 管理器类型
     */
    public void shutdownManager(String managerType) {
        DeviceManager manager = managerInstances.get(managerType);
        if (manager != null) {
            try {
                manager.shutdown();
                managerInstances.remove(managerType);
                log.info("成功关闭设备管理器: {}", managerType);
            } catch (Exception e) {
                log.error("关闭设备管理器 {} 时发生错误: {}", managerType, e.getMessage(), e);
            }
        }
    }
    
    /**
     * 关闭所有设备管理器实例
     */
    public void shutdownAllManagers() {
        for (String managerType : managerInstances.keySet()) {
            shutdownManager(managerType);
        }
    }
}